guint width;
guint height;
guint depth;
+ guint Negative; /* Negative = 1 -> top down BMP,
+ Negative = 0 -> bottom up BMP */
};
+/*
+
+These structures are actually dummies. These are according to
+the "Windows API reference guide volume II" as written by Borland,
+but GCC fiddles with the alignment of the internal members.
+
+*/
+
struct BitmapFileHeader {
- gushort bfType;
- guint bfSize;
- guint reserverd;
- guint bfOffbits;
+ gushort bfType;
+ guint bfSize;
+ guint reserverd;
+ guint bfOffbits;
};
struct BitmapInfoHeader {
- guint biSize;
- guint biWidth;
- guint biHeight;
- gushort biPlanes;
- gushort biBitCount;
- guint biCompression;
- guint biSizeImage;
- guint biXPelsPerMeter;
- guint biYPelsPerMeter;
- guint biClrUsed;
- guint biClrImportant;
+ guint biSize;
+ guint biWidth;
+ guint biHeight;
+ gushort biPlanes;
+ gushort biBitCount;
+ guint biCompression;
+ guint biSizeImage;
+ guint biXPelsPerMeter;
+ guint biYPelsPerMeter;
+ guint biClrUsed;
+ guint biClrImportant;
};
+static void DumpBIH(unsigned char *BIH)
+{ /* For debugging */
+ printf("biSize = %i \n",
+ (BIH[3] << 24) + (BIH[2] << 16) + (BIH[1] << 8) + (BIH[0]));
+ printf("biWidth = %i \n",
+ (BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) + (BIH[4]));
+ printf("biHeight = %i \n",
+ (BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) +
+ (BIH[8]));
+ printf("biPlanes = %i \n", (BIH[13] << 8) + (BIH[12]));
+ printf("biBitCount = %i \n", (BIH[15] << 8) + (BIH[14]));
+ printf("biCompress = %i \n",
+ (BIH[19] << 24) + (BIH[18] << 16) + (BIH[17] << 8) +
+ (BIH[16]));
+ printf("biSizeImage = %i \n",
+ (BIH[23] << 24) + (BIH[22] << 16) + (BIH[21] << 8) +
+ (BIH[20]));
+ printf("biXPels = %i \n",
+ (BIH[27] << 24) + (BIH[26] << 16) + (BIH[25] << 8) +
+ (BIH[24]));
+ printf("biYPels = %i \n",
+ (BIH[31] << 24) + (BIH[30] << 16) + (BIH[29] << 8) +
+ (BIH[28]));
+ printf("biClrUsed = %i \n",
+ (BIH[35] << 24) + (BIH[34] << 16) + (BIH[33] << 8) +
+ (BIH[32]));
+ printf("biClrImprtnt= %i \n",
+ (BIH[39] << 24) + (BIH[38] << 16) + (BIH[37] << 8) +
+ (BIH[36]));
+}
+
/*
This does a byte-order swap. Does glib have something like
be32_to_cpu() ??
}
-
+/* Data needed for the "state" during decompression */
+struct bmp_compression_state {
+ gint phase; /* 0 = clean,
+ 1 = count received
+ 2 = escape received
+ 3 = in "raw" run
+ 4 = Relative part 1 is next
+ 5 = Relative part 2 is next
+ 6 = end of image -> No more input allowed
+ */
+ gint RunCount;
+ gint XDelta;
+ gint YDelta;
+};
/* Progressive loading */
8 = 8 bit colormapped
1 = 1 bit bitonal
*/
+ gint Compressed;
+ struct bmp_compression_state compr;
struct headerpair Header; /* Decoded (BE->CPU) header */
-
- struct BitmapFileHeader BFH;
- struct BitmapInfoHeader BIH;
-
GdkPixbuf *pixbuf; /* Our "target" */
size_t length;
struct bmp_progressive_state *State;
int fd;
-
+
GdkPixbuf *pb;
-
+
State = image_begin_load(NULL, NULL, NULL);
-
membuf = g_malloc(4096);
-
+
g_assert(membuf != NULL);
-
+
+
while (feof(f) == 0) {
length = fread(membuf, 1, 4096, f);
- image_load_increment(State, membuf, length);
- }
+ if (length > 0)
+ image_load_increment(State, membuf, length);
+
+ }
g_free(membuf);
if (State->pixbuf != NULL)
gdk_pixbuf_ref(State->pixbuf);
return State->pixbuf;
}
-static void DecodeHeader(unsigned char *BFH,unsigned char *BIH,
- struct bmp_progressive_state *State)
+static void DecodeHeader(unsigned char *BFH, unsigned char *BIH,
+ struct bmp_progressive_state *State)
{
- State->Header.width = (BIH[7]<<24)+(BIH[6]<<16)+(BIH[5]<<8)+(BIH[4]);
- State->Header.height = (BIH[11]<<24)+(BIH[10]<<16)+(BIH[9]<<8)+(BIH[8]);
- State->Header.depth = (BIH[15]<<8)+(BIH[14]);;
+/* DumpBIH(BIH);*/
+ State->Header.width =
+ (BIH[7] << 24) + (BIH[6] << 16) + (BIH[5] << 8) + (BIH[4]);
+ State->Header.height =
+ (BIH[11] << 24) + (BIH[10] << 16) + (BIH[9] << 8) + (BIH[8]);
+ State->Header.depth = (BIH[15] << 8) + (BIH[14]);;
State->Type = State->Header.depth; /* This may be less trivial someday */
- State->HeaderSize =
- ((BFH[13]<<24)+(BFH[12]<<16)+(BFH[11]<<8)+(BFH[10]));
+ State->HeaderSize =
+ ((BFH[13] << 24) + (BFH[12] << 16) + (BFH[11] << 8) +
+ (BFH[10]));
+ if (State->HeaderSize >= 14 + 40 + 768 + 512)
+ State->HeaderSize = 14 + 40 + 768 + 512 - 1;
+
+ if ((BIH[16] != 0) || (BIH[17] != 0) || (BIH[18] != 0)
+ || (BIH[19] != 0)) {
+ State->Compressed = 1;
+ }
+
+ if (State->Header.height < 0) {
+ State->Header.height = -State->Header.height;
+ State->Header.Negative = 1;
+ }
+ if (State->Header.width < 0) {
+ State->Header.width = -State->Header.width;
+ State->Header.Negative = 0;
+ }
if (State->Type == 24)
State->LineWidth = State->Header.width * 3;
if ((State->Header.width & 7) != 0)
State->LineWidth++;
}
-
+
/* Pad to a 32 bit boundary */
- if ((State->LineWidth%4)>0)
- State->LineWidth=(State->LineWidth%4)*4+4;
-
+ if (((State->LineWidth % 4) > 0) && (State->Compressed == 0))
+ State->LineWidth = (State->LineWidth / 4) * 4 + 4;
+
if (State->LineBuf == NULL)
State->LineBuf = g_malloc(State->LineWidth);
if (State->pixbuf == NULL) {
State->pixbuf =
- gdk_pixbuf_new(ART_PIX_RGB, FALSE, 8,
- (gint) State->Header.width,
- (gint) State->Header.height);
+ gdk_pixbuf_new(ART_PIX_RGB, FALSE, 8,
+ (gint) State->Header.width,
+ (gint) State->Header.height);
+
if (State->prepared_func != NULL)
/* Notify the client that we are ready to go */
(*State->prepared_func) (State->pixbuf,
State->user_data);
}
-
+
}
/*
context->user_data = user_data;
context->HeaderSize = 54;
- context->HeaderBuf = g_malloc(14 +
- 40 + 768);
- /* 768 for the colormap */
+ context->HeaderBuf = g_malloc(14 + 40 + 768 + 512);
+ /* 768 for the colormap */
context->HeaderDone = 0;
context->LineWidth = 0;
context->Type = 0;
memset(&context->Header, 0, sizeof(struct headerpair));
+ memset(&context->compr, 0, sizeof(struct bmp_compression_state));
context->pixbuf = NULL;
if (context->LineBuf != NULL)
g_free(context->LineBuf);
+ context->LineBuf = NULL;
if (context->HeaderBuf != NULL)
g_free(context->HeaderBuf);
guchar *Pixels;
X = 0;
- Pixels = context->pixbuf->art_pixbuf->pixels +
- context->pixbuf->art_pixbuf->rowstride * (context->Header.height-context->Lines);
+ if (context->Header.Negative == 0)
+ Pixels = context->pixbuf->art_pixbuf->pixels +
+ gdk_pixbuf_get_rowstride(context->pixbuf) *
+ (context->Header.height - context->Lines - 1);
+ else
+ Pixels = context->pixbuf->art_pixbuf->pixels +
+ gdk_pixbuf_get_rowstride(context->pixbuf) *
+ context->Lines;
while (X < context->Header.width) {
Pixels[X * 3 + 0] = context->LineBuf[X * 3 + 2];
Pixels[X * 3 + 1] = context->LineBuf[X * 3 + 1];
guchar *Pixels;
X = 0;
- Pixels = context->pixbuf->art_pixbuf->pixels +
- context->pixbuf->art_pixbuf->rowstride * (context->Header.height-context->Lines);
+ if (context->Header.Negative == 0)
+ Pixels = context->pixbuf->art_pixbuf->pixels +
+ gdk_pixbuf_get_rowstride(context->pixbuf) *
+ (context->Header.height - context->Lines - 1);
+ else
+ Pixels = context->pixbuf->art_pixbuf->pixels +
+ gdk_pixbuf_get_rowstride(context->pixbuf) *
+ context->Lines;
while (X < context->Header.width) {
/* The joys of having a BGR byteorder */
Pixels[X * 3 + 0] =
- context->HeaderBuf[4*context->LineBuf[X] + 56];
+ context->HeaderBuf[4 * context->LineBuf[X] + 56];
Pixels[X * 3 + 1] =
- context->HeaderBuf[4*context->LineBuf[X] + 55];
+ context->HeaderBuf[4 * context->LineBuf[X] + 55];
Pixels[X * 3 + 2] =
- context->HeaderBuf[4*context->LineBuf[X] + 54];
+ context->HeaderBuf[4 * context->LineBuf[X] + 54];
X++;
}
}
guchar *Pixels;
X = 0;
- Pixels = context->pixbuf->art_pixbuf->pixels +
- context->pixbuf->art_pixbuf->rowstride * (context->Header.height-context->Lines);
+ if (context->Header.Negative == 0)
+ Pixels = context->pixbuf->art_pixbuf->pixels +
+ gdk_pixbuf_get_rowstride(context->pixbuf) *
+ (context->Header.height - context->Lines - 1);
+ else
+ Pixels = context->pixbuf->art_pixbuf->pixels +
+ gdk_pixbuf_get_rowstride(context->pixbuf) *
+ context->Lines;
while (X < context->Header.width) {
int Bit;
-
- Bit = (context->LineBuf[X/8])>>(7-(X&7));
+
+ Bit = (context->LineBuf[X / 8]) >> (7 - (X & 7));
Bit = Bit & 1;
/* The joys of having a BGR byteorder */
- Pixels[X * 3 + 0] =
- context->HeaderBuf[Bit + 32];
- Pixels[X * 3 + 1] =
- context->HeaderBuf[Bit + 2 + 32];
- Pixels[X * 3 + 2] =
- context->HeaderBuf[Bit + 4 + 32];
+ Pixels[X * 3 + 0] = context->HeaderBuf[Bit + 32];
+ Pixels[X * 3 + 1] = context->HeaderBuf[Bit + 2 + 32];
+ Pixels[X * 3 + 2] = context->HeaderBuf[Bit + 4 + 32];
X++;
}
}
static void OneLine(struct bmp_progressive_state *context)
{
+ context->LineDone = 0;
+ if (context->Lines >= context->Header.height)
+ return;
+
if (context->Type == 24)
OneLine24(context);
if (context->Type == 8)
if (context->Type == 1)
OneLine1(context);
- context->LineDone = 0;
- if (context->Lines > context->Header.height)
- return;
context->Lines++;
if (context->updated_func != NULL) {
gint BytesToCopy;
while (size > 0) {
+ g_assert(context->LineDone >= 0);
if (context->HeaderDone < context->HeaderSize) { /* We still
have headerbytes to do */
BytesToCopy =
buf += BytesToCopy;
context->HeaderDone += BytesToCopy;
+ } else if (context->Compressed) {
+ /* Compression is done 1 at a time for now */
+ switch (context->compr.phase) {
+ case 0:
+ if (buf[0] != 0) { /* run count */
+ context->compr.phase = 1;
+ context->compr.RunCount = buf[0];
+ } else { /* Escape */
+ context->compr.phase = 2;
+ }
+ buf++;
+ size--;
+ break;
+ case 1: /* Run count received.... */
+ while (context->compr.RunCount > 0) {
+ BytesToCopy =
+ context->LineWidth -
+ context->LineDone;
+ if (BytesToCopy >
+ context->compr.
+ RunCount) BytesToCopy =
+ context->compr.
+ RunCount;
+ if (BytesToCopy > 0) {
+ memset(context->LineBuf +
+ context->LineDone,
+ buf[0],
+ BytesToCopy);
+
+ context->compr.RunCount -=
+ BytesToCopy;
+ context->LineDone +=
+ BytesToCopy;
+ }
+ if (
+ (context->LineDone >=
+ context->LineWidth)
+ && (context->LineWidth > 0)) {
+ OneLine(context);
+ }
+ }
+ context->compr.phase = 0;
+ buf++;
+ size--;
+ break;
+ case 2: /* Escape received */
+ if (buf[0] == 0) { /* End of line */
+ context->compr.phase = 0;
+ if (context->LineDone > 0)
+ OneLine(context);
+ } else if (buf[0] == 1) { /* End of image */
+ OneLine(context);
+ context->compr.phase = 6;
+ size = 0;
+ break;
+ } else if (buf[0] == 2) { /* Cursor displacement */
+ context->compr.phase = 4;
+ } else {
+ context->compr.phase = 3;
+ context->compr.RunCount = buf[0];
+ }
+ buf++;
+ size--;
+
+ break;
+ case 3:
+ while ((context->compr.RunCount > 0)
+ && (size > 0)) {
+ BytesToCopy =
+ context->LineWidth -
+ context->LineDone;
+ if (BytesToCopy >
+ context->compr.
+ RunCount) BytesToCopy =
+ context->compr.
+ RunCount;
+ if (BytesToCopy > size)
+ BytesToCopy = size;
+
+ if (BytesToCopy > 0) {
+ memcpy(context->LineBuf +
+ context->LineDone,
+ buf, BytesToCopy);
+
+ context->compr.RunCount -=
+ BytesToCopy;
+ buf += BytesToCopy;
+ size -= BytesToCopy;
+ context->LineDone +=
+ BytesToCopy;
+ }
+ if (
+ (context->LineDone >=
+ context->LineWidth)
+ && (context->LineWidth > 0))
+ OneLine(context);
+ }
+ if (context->compr.RunCount <= 0)
+ context->compr.phase = 0;
+
+ break;
+ case 4:
+ context->compr.phase = 5;
+ context->compr.XDelta = buf[0];
+ buf++;
+ size--;
+ break;
+ case 5:
+ context->compr.phase = 0;
+ context->compr.YDelta = buf[0];
+ g_assert(0); /* No implementatio of this yet */
+ buf++;
+ size--;
+ break;
+ case 6:
+ size = 0;
+ }
+
} else {
/* Pixeldata only */
BytesToCopy =
}
- if (context->HeaderDone >= 14+40)
- DecodeHeader(context->HeaderBuf,context->HeaderBuf+14,
- context);
+ if (context->HeaderDone >= 14 + 40)
+ DecodeHeader(context->HeaderBuf,
+ context->HeaderBuf + 14, context);
}
projects / gtk4.git / commitdiff